
from typing import List, Dict, Iterable, Tuple, Callable
from matplotlib import pyplot as plt
from collections import Counter
import sys
import os
import string
import urllib.request
import requests
import curl
import pycurl
import webbrowser
import numpy as np
import math
import pandas as pd
# from IPython import qt
from matplotlib.pyplot import figure
from py.xml import raw
from requests.api import get
from matplotlib import pyplot as plt

# from scratch.working_with_data import rescale
# from scratch.multiple_regression import least_squares_fit, predict
# from scratch.gradient_descent import gradient_step
# from stats import mean, median, de_mean, standard_deviation, correlation
# from gradient_descent import minimize_stochastic, maximize_stochastic, maximize_batch
# from vector import dot, vector_add
# from normal import normal_cdf
# from matrix import make_matrix, get_column, shape, matrix_multiply
# from logistic_regression import *

import math
import os
import random
import sys
from functools import partial, reduce
from scipy.optimize import fmin_tnc
import itertools
import random
import tqdm
from typing import*
from collections import*
# from scipy import*
from sklearn.metrics import*
from numpy import *
# bltin_sum = np.sum
import random
import csv
import re


# Functions

# def add(a, b): return a + b

Vector = List[float]

Tensor = list

def vector_sum(vectors):
    """Sums all corresponding elements"""
    # Check that vectors is not empty
    assert vectors, "no vectors provided!"

    # Check the vectors are all the same size
    num_elements = len(vectors[0])
    assert all(len(v) == num_elements for v in vectors), "different sizes!"

    # the i-th element of the result is the sum of every vector[i]
    return [sum(vector[i] for vector in vectors)
            for i in range(num_elements)]

def scalar_multiply(c , v):
    """Multiplies every element by c"""
    return [c * v_i for v_i in v]

def vector_mean(vectors):
    """Computes the element-wise average"""
    n = len(vectors)
    m = sum(vectors,axis=0)
    vec_mean = np.multiply(1/n,m)
    return vec_mean

def de_mean(xs):
    """Translate xs by subtracting its mean (so the result has mean 0)"""
    x_bar = np.mean(xs)
    d_mean = [x - x_bar for x in xs]
    return d_mean

def dot(v, w):
    """Computes v_1 * w_1 + ... + v_n * w_n"""
    assert len(v) == len(w), "vectors must be same length"

#     return np.sum(v_i * w_i for v_i, w_i in zip(v, w))
#     gen = 
    return np.sum(np.fromiter((v_i * w_i for v_i, w_i in zip(v, w)),float))

def sum_of_squares(v):
    """Returns v_1 * v_1 + ... + v_n * v_n"""
    return dot(v, v)

def variance(xs):
    """Almost the average squared deviation from the mean"""
    assert len(xs) >= 2, "variance requires at least two elements"

    n = len(xs)
    deviations = de_mean(xs)
    vari = sum_of_squares(deviations)/(n-1)
    return vari

# Standard deviation                        
def standard_deviation(xs):
    """The standard deviation is the square root of the variance"""
    std_dev = np.sqrt(variance(xs)) 
    return std_dev

def scale(data):
    """returns the mean and standard deviation for each position"""
    dim = data.shape[0]
    
    # Vector Mean
#     n = len(data)
#     m = np.sum(data,axis=0)
#     means = np.multiply(1/n,m)
    means = vector_mean(data)
    
    # Standard Deviaiton
    stdevs = [standard_deviation([vector[i] for vector in data])
              for i in range(dim)]
    return means,stdevs

def rescale(data):
    """
    Rescales the input data so that each position has
    mean 0 and standard deviation 1. (Leaves a position
    as is if its standard deviation is 0.)
    """
    dim = data.shape[0]
    means, stdevs = scale(data)
    
    means = list(means)
    stdevs = list(stdevs)

    # Make a copy of each vector
    rescaled = [v[:] for v in data]
    v0 = []
    for v in rescaled:
        v = list(v)
        for i in range(dim):
            if stdevs[i] > 0:
                v[i] = (v[i] - means[i]) / stdevs[i]
        v0.append(v)

    return v0

def gradient_step(v, gradient, step_size):
    """Moves `step_size` in the `gradient` direction from `v`"""
    assert len(v) == len(gradient)
    step = scalar_multiply(step_size, gradient)
    grad_step = np.add(v,step)
    return grad_step

# def predict(alpha, beta, x_i):
#     pred = beta * x_i + alpha
#     return pred

# def error(x, y, beta):
#     """
#     The error from predicting beta * x_i + alpha
#     when the actual value is y_i
#     """
#     err_fin = predict(alpha, beta, x_i) - y_i
#     return err_fin

def predict(x, beta):
    """assumes that the first element of x is 1"""
    return dot(x, beta)

def error(x, y, beta):
    return predict(x, beta) - y 

def sqerror_gradient(x, y, beta):
    err = error(x, y, beta)
    err_fin = [2 * err * x_i for x_i in x]
    return err_fin

def least_squares_fit(xs, ys, learning_rate = 0.001, num_steps = 1000, batch_size = 1):
    """
    Find the beta that minimizes the sum of squared errors
    assuming the model y = dot(x, beta).
    """
    # Start with a random guess
    guess = [np.random.random() for _ in xs[0]]

    for _ in tqdm.trange(num_steps, desc="least squares fit"):
        for start in range(0, len(xs), batch_size):
            batch_xs = xs[start:start+batch_size]
            batch_ys = ys[start:start+batch_size]

            gradient = vector_mean([sqerror_gradient(x, y, guess)
                                    for x, y in zip(batch_xs, batch_ys)])
            guess = gradient_step(guess, gradient, -learning_rate)

    return guess

def logistic(x):
    return 1.0 / (1 + math.exp(-x))

def logistic_prime(x):
    y = logistic(x)
    return y * (1 - y)

def _negative_log_likelihood(x, y, beta):
    """The negative log likelihood for one data point""" 
    if y == 1:
        return -math.log(logistic(dot(x, beta)))
    else:
        return -math.log(1 - logistic(dot(x, beta)))
    
def negative_log_likelihood(xs, ys, beta):
    return sum(_negative_log_likelihood(x, y, beta)
               for x, y in zip(xs, ys))

def _negative_log_partial_j(x, y, beta, j):
    """
    The jth partial derivative for one data point.
    Here i is the index of the data point.
    """
    return -(y - logistic(dot(x, beta))) * x[j]

def _negative_log_gradient(x, y, beta):
    """
    The gradient for one data point.
    """
    return [_negative_log_partial_j(x, y, beta, j)
            for j in range(len(beta))]

def negative_log_gradient(xs, ys,beta):
    return vector_sum([_negative_log_gradient(x, y, beta)
                       for x, y in zip(xs, ys)])

def split_data(data, prob):
    """Split data into fractions [prob, 1 - prob]"""
    data = data[:]                    # Make a shallow copy
    random.shuffle(data)              # because shuffle modifies the list.
    cut = int(len(data) * prob)       # Use prob to find a cutoff
    return data[:cut], data[cut:]     # and split the shuffled list there.

def train_test_split(xs, ys, test_pct):
     # Generate the indices and split them
    idxs = [i for i in range(len(xs))]
    train_idxs, test_idxs = split_data(idxs, 1 - test_pct)

    return ([xs[i] for i in train_idxs],  # x_train 
            [xs[i] for i in test_idxs],   # x_test
            [ys[i] for i in train_idxs],  # y_train
            [ys[i] for i in test_idxs])   # y_test
                                                                
def step_function(x: float) -> float:
    return 1.0 if x >= 0 else 0.0

def sigmoid(t: float) -> float: 
    return 1 / (1 + math.exp(-t))

# Gradient Descent - step
def gradient_step(v: Vector, gradient: Vector, step_size: float):
    """Moves `step_size` in the `gradient` direction from `v`"""
    assert len(v) == len(gradient)
    step = scalar_multiply(step_size, gradient)
    return add(v, step)

def sum_of_squares_gradient(v: Vector) -> Vector:
    return [2 * v_i for v_i in v]

def squared_distance(v: Vector, w: Vector) -> float:
    """Computes (v_1 - w_1) ** 2 + ... + (v_n - w_n) ** 2"""
    return sum_of_squares(subtract(v, w))

def distance(v: Vector, w: Vector) -> float:
    """Computes the distance between v and w"""
    return math.sqrt(squared_distance(v, w))

def shape(tensor: Tensor) -> List[int]:
    sizes: List[int] = []
    while isinstance(tensor, list):
        sizes.append(len(tensor))
        tensor = tensor[0]
    return sizes

def is_1d(tensor: Tensor) -> bool:
    """
    If tensor[0] is a list, it's a higher-order tensor.
    Otherwise, tensor is 1-dimensional (that is, a vector).
    """
    return not isinstance(tensor[0], list)

def tensor_sum(tensor: Tensor) -> float:
    """Sums up all the values in the tensor"""
    if is_1d(tensor):
        return sum(tensor)  # just a list of floats, use Python sum
    else:
        return sum(tensor_sum(tensor_i)      # Call tensor_sum on each row
                   for tensor_i in tensor)   # and sum up those results.

def tensor_apply(f: Callable[[float], float], tensor: Tensor) -> Tensor:
    """Applies f elementwise""" 
    if is_1d(tensor):
        return [f(x) for x in tensor]
    else:
        return [tensor_apply(f, tensor_i) for tensor_i in tensor] 
    
def zeros_like(tensor: Tensor) -> Tensor:
    return tensor_apply(lambda _: 0.0, tensor)


def tensor_combine(f: Callable[[float, float], float],
                   t1: Tensor,
                   t2: Tensor) -> Tensor:
    """Applies f to corresponding elements of t1 and t2"""
    if is_1d(t1):
        return [f(x, y) for x, y in zip(t1, t2)]
    else:
        return [tensor_combine(f, t1_i, t2_i)
                for t1_i, t2_i in zip(t1, t2)]
    
def inverse_normal_cdf(p: float,
                       mu: float = 0,
                       sigma: float = 1,
                       tolerance: float = 0.00001) -> float:
    """Find approximate inverse using binary search"""

    # if not standard, compute standard and rescale
    if mu != 0 or sigma != 1:
        return mu + sigma * inverse_normal_cdf(p, tolerance=tolerance)

    low_z = -10.0                      # normal_cdf(-10) is (very close to) 0
    hi_z  =  10.0                      # normal_cdf(10)  is (very close to) 1
    while hi_z - low_z > tolerance:
        mid_z = (low_z + hi_z) / 2     # Consider the midpoint
        mid_p = normal_cdf(mid_z)      # and the CDF's value there
        if mid_p < p:
            low_z = mid_z              # Midpoint too low, search above it
        else:
            hi_z = mid_z               # Midpoint too high, search below it

    return mid_z

def normal_cdf(x: float, mu: float = 0, sigma: float = 1) -> float:
    return (1 + math.erf((x - mu) / math.sqrt(2) / sigma)) / 2


def num_differences(v1, v2):
    assert len(v1) == len(v2)
    return len([x1 for x1, x2 in zip(v1, v2) if x1 != x2])


def cluster_means(k: int,
                  inputs: List[Vector],
                  assignments: List[int]) -> List[Vector]:
    # clusters[i] contains the inputs whose assignment is i
    clusters = [[] for i in range(k)]
    for input, assignment in zip(inputs, assignments):
        clusters[assignment].append(input)

    # if a cluster is empty, just use a random point
    return [vector_mean(cluster) if cluster else random.choice(inputs)
            for cluster in clusters]


class KMeans:
    def __init__(self, k: int) -> None:
        self.k = k                      # number of clusters
        self.means = None

    def classify(self, input: Vector) -> int:
        """return the index of the cluster closest to the input"""
        return min(range(self.k),
                   key=lambda i: squared_distance(input, self.means[i]))

    def train(self, inputs: List[Vector]) -> None:
        # Start with random assignments
        assignments = [random.randrange(self.k) for _ in inputs]

        with tqdm.tqdm(itertools.count()) as t:
            for _ in t:
                # Compute means and find new assignments
                self.means = cluster_means(self.k, inputs, assignments)
                new_assignments = [self.classify(input) for input in inputs]

                # Check how many assignments changed and if we're done
                num_changed = num_differences(assignments, new_assignments)
                if num_changed == 0:
                    return

                # Otherwise keep the new assignments, and compute new means
                assignments = new_assignments
                self.means = cluster_means(self.k, inputs, assignments)
                t.set_description(f"changed: {num_changed} / {len(inputs)}")
                
def squared_clustering_errors(inputs, k):
    """finds the total squared error from k-means clustering the
inputs"""
    clusterer = KMeans(k)
    clusterer.train(inputs)
    means = clusterer.means
    assignments = [clusterer.classify(input) for input in inputs]

    return sum(squared_distance(input, means[cluster])
               for input, cluster in zip(inputs, assignments))

def recolor(pixel):
    cluster = clusterer.classify(pixel)        # index of the closest cluster
    return clusterer.means[cluster]            # mean of the closest cluster

def get_values(cluster):
    if isinstance(cluster, Leaf):
        return [cluster.value]
    else:
        return [value
                for child in cluster.children
                for value in get_values(child)]


def cluster_distance(cluster1,
                     cluster2,
                     distance_agg: Callable = min):
    """
    compute all the pairwise distances between cluster1 and cluster2
    and apply the aggregation function _distance_agg_ to the resulting
list
    """
    return distance_agg([distance(v1, v2) for v1 in get_values(cluster1) for v2 in get_values(cluster2)])

def get_merge_order(cluster):
    if isinstance(cluster, Leaf):
        return float('inf')  # was never merged
    else:
        return cluster.order
    
def get_children(cluster):
    if isinstance(cluster, Leaf):
        raise TypeError("Leaf has no children")
    else:
        return cluster.children
    
class Merged(NamedTuple):
    children: tuple
    order: int

def bottom_up_cluster(inputs: List[Vector],
                      distance_agg: Callable = min):
    # Start with all leaves
    clusters: List[Cluster] = [Leaf(input) for input in inputs]

    def pair_distance(pair):
        return cluster_distance(pair[0], pair[1], distance_agg)
 
    # as long as we have more than one cluster left...
    while len(clusters) > 1:
        # find the two closest clusters
        c1, c2 = min(((cluster1, cluster2) 
                      for i, cluster1 in enumerate(clusters)
                      for cluster2 in clusters[:i]),
                      key=pair_distance)

        # remove them from the list of clusters
        clusters = [c for c in clusters if c != c1 and c != c2]

        # merge them, using merge_order = # of clusters left
        merged_cluster = Merged((c1, c2), order=len(clusters))

        # and add their merge
        clusters.append(merged_cluster)

    # when there's only one cluster left, return it
    return clusters[0]

def generate_clusters(base_cluster,
                      num_clusters):
    # start with a list with just the base cluster
    clusters = [base_cluster]

    # as long as we don't have enough clusters yet...
    while len(clusters) < num_clusters:
        # choose the last-merged of our clusters
        next_cluster = min(clusters, key=get_merge_order)
        # remove it from the list
        clusters = [c for c in clusters if c != next_cluster]

        # and add its children to the list (i.e., unmerge it)
        clusters.extend(get_children(next_cluster))

    # once we have enough clusters...
    return clusters

def cosine_similarity(v1: Vector, v2: Vector) -> float:
    return dot(v1, v2) / math.sqrt(dot(v1, v1) * dot(v2, v2))

def random_tensor(*dims: int, init: str = 'normal') -> Tensor:
    if init == 'normal':
        return random_normal(*dims)
    elif init == 'uniform':
        return random_uniform(*dims)
    elif init == 'xavier':
        variance = len(dims) / sum(dims)
        return random_normal(*dims, variance=variance)
    else:
        raise ValueError(f"unknown init: {init}")
        
def random_normal() -> float:
    """Returns a random draw from a standard normal distribution"""
    return inverse_normal_cdf(random.random())

def random_normal(*dims: int,
                  mean: float = 0.0,
                  variance: float = 1.0) -> Tensor:
    if len(dims) == 1:
        return [mean + variance * inverse_normal_cdf(random.random())
                for _ in range(dims[0])]
    else:
        return [random_normal(*dims[1:], mean=mean, variance=variance)                
                for _ in range(dims[0])]


def random_uniform(*dims: int) -> Tensor:
    if len(dims) == 1:
        return [random.random() for _ in range(dims[0])]
    else:
        return [random_uniform(*dims[1:]) for _ in range(dims[0])]


users_interests = [
    ["Hadoop", "Big Data", "HBase", "Java", "Spark", "Storm",
"Cassandra"],
    ["NoSQL", "MongoDB", "Cassandra", "HBase", "Postgres"],
    ["Python", "scikit-learn", "scipy", "numpy", "statsmodels",
"pandas"],
    ["R", "Python", "statistics", "regression", "probability"],
    ["machine learning", "regression", "decision trees", "libsvm"],
    ["Python", "R", "Java", "C++", "Haskell", "programming languages"],
    ["statistics", "probability", "mathematics", "theory"],
    ["machine learning", "scikit-learn", "Mahout", "neural networks"],
    ["neural networks", "deep learning", "Big Data", "artificial intelligence"],
    ["Hadoop", "Java", "MapReduce", "Big Data"],
    ["statistics", "R", "statsmodels"],
    ["C++", "deep learning", "artificial intelligence", "probability"],
    ["pandas", "R", "Python"],
    ["databases", "HBase", "Postgres", "MySQL", "MongoDB"], 
    ["libsvm", "regression", "support vector machines"]
]


popular_interests = Counter(interest
                            for user_interests in users_interests
                            for interest in user_interests)


popular_interests = Counter(interest
                            for user_interests in users_interests
                            for interest in user_interests)
popular_interests

Counter({'Hadoop': 2,
         'Big Data': 3,
         'HBase': 3,
         'Java': 3,
         'Spark': 1,
         'Storm': 1,
         'Cassandra': 2,
         'NoSQL': 1,
         'MongoDB': 2,
         'Postgres': 2,
         'Python': 4,
         'scikit-learn': 2,
         'scipy': 1,
         'numpy': 1,
         'statsmodels': 2,
         'pandas': 2,
         'R': 4,
         'statistics': 3,
         'regression': 3,
         'probability': 3,
         'machine learning': 2,
         'decision trees': 1,
         'libsvm': 2,
         'C++': 2,
         'Haskell': 1,
         'programming languages': 1,
         'mathematics': 1,
         'theory': 1,
         'Mahout': 1,
         'neural networks': 2,
         'deep learning': 2,
         'artificial intelligence': 2,
         'MapReduce': 1,
         'databases': 1,
         'MySQL': 1,
         'support vector machines': 1})


def most_popular_new_interests(
        user_interests: List[str],
        max_results: int = 5) -> List[Tuple[str, int]]:
    suggestions = [(interest, frequency)
                   for interest, frequency in
popular_interests.most_common()
                   if interest not in user_interests]
    return suggestions[:max_results]


most_popular_new_interests(["NoSQL", "MongoDB", "Cassandra", "HBase", "Postgres"])

[('Python', 4), ('R', 4), ('Big Data', 3), ('Java', 3), ('statistics', 3)]


unique_interests = sorted({interest
                           for user_interests in users_interests
                           for interest in user_interests})
unique_interests[:6]

['Big Data', 'C++', 'Cassandra', 'HBase', 'Hadoop', 'Haskell']


def make_user_interest_vector(user_interests: List[str]) -> List[int]:
    """
    Given a list of interests, produce a vector whose ith element is 1
    if unique_interests[i] is in the list, 0 otherwise
    """
    return [1 if interest in user_interests else 0
            for interest in unique_interests]


user_interest_vectors = [make_user_interest_vector(user_interests)
                         for user_interests in users_interests]


user_similarities = [[cosine_similarity(interest_vector_i,
interest_vector_j) for interest_vector_j in user_interest_vectors] 
for interest_vector_i in user_interest_vectors]


def most_similar_users_to(user_id: int) -> List[Tuple[int, float]]:
    pairs = [(other_user_id, similarity)                      # Find other
             for other_user_id, similarity in                 # users with
                enumerate(user_similarities[user_id])         # nonzero
             if user_id != other_user_id and similarity > 0]  # similarity.

    return sorted(pairs,                                      # Sort them
                  key=lambda pair: pair[-1],                  # most similar
                  reverse=True)                               # first.


 most_similar_users_to(0)

[(9, 0.5669467095138409),
 (1, 0.3380617018914066),
 (8, 0.1889822365046136),
 (13, 0.1690308509457033),
 (5, 0.1543033499620919)]


def user_based_suggestions(user_id: int,
                           include_current_interests: bool = False):
    # Sum up the similarities
    suggestions: Dict[str, float] = defaultdict(float)
    for other_user_id, similarity in most_similar_users_to(user_id): 
        for interest in users_interests[other_user_id]:
            suggestions[interest] += similarity

    # Convert them to a sorted list 
    suggestions = sorted(suggestions.items(),
                     key=lambda pair: pair[-1],  # weight
                     reverse=True)

    # And (maybe) exclude already interests
    if include_current_interests:
        return suggestions
    else:
        return [(suggestion, weight)
                for suggestion, weight in suggestions
                if suggestion not in users_interests[user_id]]


user_based_suggestions(0)

[('MapReduce', 0.5669467095138409),
 ('MongoDB', 0.50709255283711),
 ('Postgres', 0.50709255283711),
 ('NoSQL', 0.3380617018914066),
 ('neural networks', 0.1889822365046136),
 ('deep learning', 0.1889822365046136),
 ('artificial intelligence', 0.1889822365046136),
 ('databases', 0.1690308509457033),
 ('MySQL', 0.1690308509457033),
 ('Python', 0.1543033499620919),
 ('R', 0.1543033499620919),
 ('C++', 0.1543033499620919),
 ('Haskell', 0.1543033499620919),
 ('programming languages', 0.1543033499620919)]


interest_user_matrix = [[user_interest_vector[j]
                         for user_interest_vector in user_interest_vectors]
                        for j, _ in enumerate(unique_interests)]


interest_similarities = [[cosine_similarity(user_vector_i, user_vector_j)
                          for user_vector_j in interest_user_matrix] 
                         for user_vector_i in interest_user_matrix]


def most_similar_interests_to(interest_id: int):
    similarities = interest_similarities[interest_id]
    pairs = [(unique_interests[other_interest_id], similarity)
             for other_interest_id, similarity in enumerate(similarities)
             if interest_id != other_interest_id and similarity > 0]
    return sorted(pairs,
                  key=lambda pair: pair[-1],
                  reverse=True)


# most_similar_interests_to('Big Data')
# interest_similarities


def item_based_suggestions(user_id: int,
                           include_current_interests: bool = False):
    # Add up the similar interests
    suggestions = defaultdict(float)
    user_interest_vector = user_interest_vectors[user_id]
    for interest_id, is_interested in enumerate(user_interest_vector):
        if is_interested == 1:
            similar_interests = most_similar_interests_to(interest_id)
            for interest, similarity in similar_interests:
                suggestions[interest] += similarity

    # Sort them by weight 
    suggestions = sorted(suggestions.items(),
                         key=lambda pair: pair[-1],
                         reverse=True)
    if include_current_interests:
        return suggestions
    else:
        return [(suggestion, weight)
                for suggestion, weight in suggestions
                if suggestion not in users_interests[user_id]]


item_based_suggestions(0)

[('MapReduce', 1.861807319565799),
 ('MongoDB', 1.3164965809277263),
 ('Postgres', 1.3164965809277263),
 ('NoSQL', 1.2844570503761732),
 ('MySQL', 0.5773502691896258),
 ('databases', 0.5773502691896258),
 ('Haskell', 0.5773502691896258),
 ('programming languages', 0.5773502691896258),
 ('artificial intelligence', 0.4082482904638631),
 ('deep learning', 0.4082482904638631),
 ('neural networks', 0.4082482904638631),
 ('C++', 0.4082482904638631),
 ('Python', 0.2886751345948129),
 ('R', 0.2886751345948129)]


# This points to the current directory, modify if your files are elsewhere.
MOVIES = "u.item"   # pipe-delimited: movie_id|title|...
RATINGS = "u.data"  # tab-delimited: user_id, movie_id, rating, timestamp


class Rating(NamedTuple):
    user_id: str 
    movie_id: str
    rating: float


# We specify this encoding to avoid a UnicodeDecodeError.
# See: https://stackoverflow.com/a/53136168/1076346.
with open(MOVIES, encoding="iso-8859-1") as f:
    reader = csv.reader(f, delimiter="|")
    movies = {movie_id: title for movie_id, title, *_ in reader}


# Create a list of [Rating]
with open(RATINGS, encoding="iso-8859-1") as f:
    reader = csv.reader(f, delimiter="\t")
    ratings = [Rating(user_id, movie_id, float(rating))
               for user_id, movie_id, rating, _ in reader]


 
# Data structure for accumulating ratings by movie_id
star_wars_ratings = {movie_id: []
                     for movie_id, title in movies.items()
                     if re.search("Star Wars|Empire Strikes|Jedi", title)}

print(star_wars_ratings)
 
# Iterate over ratings, accumulating the Star Wars ones
for rating in ratings:
    if rating.movie_id in star_wars_ratings:
        star_wars_ratings[rating.movie_id].append(rating.rating)
 
# Compute the average rating for each movie
# avg_ratings = [(sum(title_ratings) / len(title_ratings), movie_id)
#                for movie_id, title_ratings in star_wars_ratings.items()]

avg_ratings = [(np.mean(title_ratings), movie_id)
               for movie_id, title_ratings in star_wars_ratings.items()]

print(avg_ratings)
 
# And then print them in order
for avg_rating, movie_id in sorted(avg_ratings, reverse=True):
    print(f"{avg_rating:.2f} {movies[movie_id]}")

len(star_wars_ratings)

{'50': [], '172': [], '181': []}
[(4.3584905660377355, '50'), (4.204359673024523, '172'), (4.007889546351085, '181')]
4.36 Star Wars (1977)
4.20 Empire Strikes Back, The (1980)
4.01 Return of the Jedi (1983)

3


random.seed(0)
random.shuffle(ratings)

split1 = int(len(ratings) * 0.7)
split2 = int(len(ratings) * 0.85)

train = ratings[:split1]              # 70% of the data
validation = ratings[split1:split2]   # 15% of the data
test = ratings[split2:]               # 15% of the data


## avg_rating = np.sum(rating.rating for rating in train) / len(train)
baseline_error = np.sum((rating.rating - avg_rating) ** 2
                     for rating in test) / len(test)

C:\Users\USER\AppData\Local\Temp/ipykernel_17280/359367549.py:2: DeprecationWarning: Calling np.sum(generator) is deprecated, and in the future will give a different result. Use np.sum(np.fromiter(generator)) or the python sum builtin instead.
  baseline_error = np.sum((rating.rating - avg_rating) ** 2


EMBEDDING_DIM = 2
 
# Find unique ids
user_ids = {rating.user_id for rating in ratings}
movie_ids = {rating.movie_id for rating in ratings}

a_user = Counter(user_ids)
# len(a_user)

# print(user_ids)
 
# Then create a random vector per id
user_vectors = {user_id: random_tensor(EMBEDDING_DIM)
                for user_id in user_ids}
movie_vectors = {movie_id: random_tensor(EMBEDDING_DIM)
                 for movie_id in movie_ids}

dict2 = {}
for user_id in user_ids:
    dict2[user_id] = random_tensor(EMBEDDING_DIM)

print(dict2['922'])
print(user_vectors['922'])

out = dict(list(dict2.items())[:1])
print(out)
out1 = list(dict2.items())[0]
print(out1)
d2 = list(dict2.items())
print(d2[0])

[-0.2129650115966797, -0.7769489288330078]
[-1.5976428985595703, -0.2919292449951172]
{'221': [0.4108142852783203, 2.300424575805664]}
('221', [0.4108142852783203, 2.300424575805664])
('221', [0.4108142852783203, 2.300424575805664])


def loop(dataset: List[Rating],
         learning_rate: float = None) -> None:
    with tqdm.tqdm(dataset) as t: 
        loss = 0.0
        for i, rating in enumerate(t):
            movie_vector = movie_vectors[rating.movie_id]
            print('Movie Vector: ',movie_vector)
            user_vector = user_vectors[rating.user_id]
            print('User Vector: ', user_vector)
            predicted = dot(user_vector, movie_vector)
            print('Predicted: ',predicted)
            error = predicted - rating.rating
            loss += error ** 2

            if learning_rate is not None:
                #     predicted = m_0 * u_0 + ... + m_k * u_k
                # So each u_j enters output with coefficent m_j
                # and each m_j enters output with coefficient u_j
                user_gradient = [error * m_j for m_j in movie_vector]
                movie_gradient = [error * u_j for u_j in user_vector]

                # Take gradient steps
                for j in range(EMBEDDING_DIM):
                    user_vector[j] -= learning_rate * user_gradient[j]
                    movie_vector[j] -= learning_rate * movie_gradient[j]

            t.set_description(f"avg loss: {loss / (i + 1)}")


learning_rate = 0.05
for epoch in range(20):
    learning_rate *= 0.9
    print(epoch, learning_rate)
    loop(train, learning_rate=learning_rate)
    loop(validation)
loop(test)

0 0.045000000000000005

avg loss: 18.723210227353512:   0%|                                                | 91/70000 [00:00<01:17, 903.98it/s]

Movie Vector:  [0.6127834320068359, 0.39618492126464844]
User Vector:  [-1.3004779815673828, -0.5169773101806641]
Predicted:  -1.0017299757237197
Movie Vector:  [-0.3542041778564453, -1.2061023712158203]
User Vector:  [1.1014461517333984, 0.7700061798095703]
Predicted:  -1.318843107947032
Movie Vector:  [-0.5251789093017578, -2.0674610137939453]
User Vector:  [1.5749454498291016, 1.6793346405029297]
Predicted:  -4.299087031904492
Movie Vector:  [1.4825916290283203, -1.9130611419677734]
User Vector:  [-0.7299518585205078, -1.0254192352294922]
Predicted:  0.8794691781076835
Movie Vector:  [0.2088642120361328, 0.8969020843505859]
User Vector:  [0.8080196380615234, -1.3551998138427734]
Predicted:  -1.0467151527336682
Movie Vector:  [-2.4300289154052734, -0.2781200408935547]
User Vector:  [0.9499073028564453, 0.20508766174316406]
Predicted:  -2.3653412017665687
Movie Vector:  [0.6540966033935547, 0.6371402740478516]
User Vector:  [0.5515384674072266, 0.8195972442626953]
Predicted:  0.8829578509903513
Movie Vector:  [0.11872291564941406, 0.9619426727294922]
User Vector:  [0.09224891662597656, -0.0009822845458984375]
Predicted:  0.010007158925873227
Movie Vector:  [-0.9961795806884766, 1.1876773834228516]
User Vector:  [-2.101449966430664, 0.9702777862548828]
Predicted:  3.245798528769228
Movie Vector:  [0.8227634429931641, -1.9394779205322266]
User Vector:  [0.3750133514404297, 1.3031482696533203]
Predicted:  -2.2188800199728576
Movie Vector:  [0.5447292327880859, 2.043733596801758]
User Vector:  [0.5285549163818359, 0.5409908294677734]
Predicted:  1.3935604478319874
Movie Vector:  [0.27543067932128906, -1.6177845001220703]
User Vector:  [1.097555160522461, 0.1688098907470703]
Predicted:  0.02920233873737743
Movie Vector:  [0.07037162780761719, 0.04885673522949219]
User Vector:  [0.7779598236083984, 0.6219768524169922]
Predicted:  0.08513405755365966
Movie Vector:  [-1.3356685638427734, 0.9784221649169922]
User Vector:  [-1.5904521942138672, -0.4330158233642578]
Predicted:  1.7006447187668527
Movie Vector:  [0.44754981994628906, -1.5433788299560547]
User Vector:  [-0.29166221618652344, -0.47539710998535156]
Predicted:  0.6031844630342675
Movie Vector:  [-1.8858623504638672, 0.7815265655517578]
User Vector:  [-1.6925525665283203, 1.9013690948486328]
Predicted:  4.6778916199400555
Movie Vector:  [-1.3617420196533203, 0.6269741058349609]
User Vector:  [1.4284229278564453, -0.03563880920410156]
Predicted:  -1.9674881332321092
Movie Vector:  [1.8929004669189453, -0.8957195281982422]
User Vector:  [0.22767066955566406, 1.050405502319336]
Predicted:  -0.5099108042486478
Movie Vector:  [-0.09791374206542969, -1.7014026641845703]
User Vector:  [-0.8336353302001953, -0.46578407287597656]
Predicted:  0.8741106172237778
Movie Vector:  [1.5677738189697266, -1.3573360443115234]
User Vector:  [-0.7687664031982422, -0.2696514129638672]
Predicted:  -0.8392442576223402
Movie Vector:  [-1.321706771850586, -0.22332191467285156]
User Vector:  [-2.028169631958008, -1.1409854888916016]
Predicted:  2.9354526010138215
Movie Vector:  [-0.6076526641845703, 1.2961864471435547]
User Vector:  [-0.3980541229248047, -0.9238719940185547]
Predicted:  -0.9556317092574318
Movie Vector:  [1.3800889517428332, -2.057054496768043]
User Vector:  [-0.16936302185058594, 0.9328556060791016]
Predicted:  -2.1526708546100677
Movie Vector:  [-1.834230826411776, 0.7235250676402675]
User Vector:  [0.4906177520751953, 1.2113094329833984]
Predicted:  -0.023493465408565894
Movie Vector:  [-2.4228572845458984, 0.1487445831298828]
User Vector:  [-0.7067966461181641, 0.14906883239746094]
Predicted:  1.734640584072622
Movie Vector:  [-2.5180721282958984, 0.27472496032714844]
User Vector:  [2.0215702056884766, -0.8211231231689453]
Predicted:  -5.316042607773852
Movie Vector:  [-1.524972915649414, 1.2241649627685547]
User Vector:  [-1.118936538696289, -0.9597110748291016]
Predicted:  0.5315032436556066
Movie Vector:  [0.38582801818847656, -1.4858150482177734]
User Vector:  [0.17905235290527344, -0.4926586151123047]
Predicted:  0.8010829984414158
Movie Vector:  [-0.26719093322753906, 1.2688159942626953]
User Vector:  [-1.0457324981689453, 0.04448890686035156]
Predicted:  0.3358584786838037
Movie Vector:  [1.5375041961669922, 0.2823162078857422]
User Vector:  [0.04305839538574219, -1.0187625885009766]
Predicted:  -0.22141072713566246
Movie Vector:  [0.16028404235839844, 1.5420818328857422]
User Vector:  [-0.24209022521972656, -1.7581462860107422]
Predicted:  -2.7500086471263785
Movie Vector:  [0.3560063511233802, 0.650117241375913]
User Vector:  [0.11357307434082031, -1.0856914520263672]
Predicted:  -0.6653939959948514
Movie Vector:  [-0.4875659942626953, 1.400136947631836]
User Vector:  [-1.1127948760986328, -0.7240200042724609]
Predicted:  -0.4711662186309695
Movie Vector:  [-1.1858844757080078, -0.18851280212402344]
User Vector:  [-0.9762668609619141, 0.013589859008789062]
Predicted:  1.1551778521607048
Movie Vector:  [1.163034439086914, -0.1996326446533203]
User Vector:  [1.0581302642822266, -0.3279399871826172]
Predicted:  1.2961094653292093
Movie Vector:  [-0.5177402496337891, -0.3037548065185547]
User Vector:  [0.6341648101806641, -0.6143474578857422]
Predicted:  -0.14172165392665192
Movie Vector:  [-0.18935203552246094, -1.281881332397461]
User Vector:  [0.2231121063232422, 0.36963462829589844]
Predicted:  -0.5160744613021961
Movie Vector:  [0.7268238067626953, 1.2630939483642578]
User Vector:  [-0.5217605791606992, -1.294058716824865]
Predicted:  -2.0137457444137916
Movie Vector:  [0.2792644500732422, -0.9471607208251953]
User Vector:  [1.0998249053955078, -0.06560325622558594]
Predicted:  0.36927882483723806
Movie Vector:  [2.9022693634033203, -0.6752872467041016]
User Vector:  [1.7870807647705078, -0.5527782440185547]
Predicted:  5.559873851962038
Movie Vector:  [0.6313800811767578, 0.3920269012451172]
User Vector:  [-0.4375934600830078, -0.5309581756591797]
Predicted:  -0.4844376826440566
Movie Vector:  [-0.31624794006347656, 1.4789104461669922]
User Vector:  [-0.20239830017089844, -0.6244754791259766]
Predicted:  -0.8595352639531484
Movie Vector:  [1.0952091217041016, 0.3870105743408203]
User Vector:  [0.14983177185058594, -1.131296157836914]
Predicted:  -0.27372645254217787
Movie Vector:  [-0.28191566467285156, -1.0595035552978516]
User Vector:  [1.2026309967041016, 0.34234046936035156]
Predicted:  -0.7017514612016384
Movie Vector:  [0.9354877471923828, 2.1807193756103516]
User Vector:  [0.5682390176614793, 0.8476626540643339]
Predicted:  2.3800950121983373
Movie Vector:  [-0.4952526092529297, -0.7034778594970703]
User Vector:  [-1.1167430877685547, -1.426076889038086]
Predicted:  1.556283445461304
Movie Vector:  [0.6757259368896484, -0.6178951263427734]
User Vector:  [0.40381431579589844, -0.5694675445556641]
Predicted:  0.6247390272619668
Movie Vector:  [-0.7751369476318359, -0.7035350799560547]
User Vector:  [0.21668434143066406, -0.5002689361572266]
Predicted:  0.1839967069827253
Movie Vector:  [2.825345993041992, -0.06176948547363281]
User Vector:  [1.4082050323486328, 0.9606838226318359]
Predicted:  3.9193255001009675
Movie Vector:  [-0.5201435089111328, -0.06064414978027344]
User Vector:  [0.7769107818603516, 0.6810474395751953]
Predicted:  -0.4454066431208048
Movie Vector:  [-2.1886348724365234, 0.29770851135253906]
User Vector:  [-1.1118221282958984, 0.5411815643310547]
Predicted:  2.5944870398234343
Movie Vector:  [0.029268264770507812, -0.6501674652099609]
User Vector:  [0.9513187408447266, 0.42038917541503906]
Predicted:  -0.245479915793112
Movie Vector:  [0.43229103088378906, 1.0814762115478516]
User Vector:  [-0.7191753387451172, 0.46479225158691406]
Predicted:  0.1917687148306868
Movie Vector:  [-1.311044692993164, -1.2243938446044922]
User Vector:  [1.3788127034263833, 0.9072228905183846]
Predicted:  -2.918483200293722
Movie Vector:  [-0.4580974578857422, 0.26297569274902344]
User Vector:  [1.0714435577392578, -1.398458480834961]
Predicted:  -0.8585861578467302
Movie Vector:  [0.20742400661924087, 0.15842975507276874]
User Vector:  [-0.40085792541503906, -0.6243991851806641]
Predicted:  -0.1820709669504732
Movie Vector:  [0.7495021820068359, 0.8399486541748047]
User Vector:  [-0.9202289581298828, -1.118001937866211]
Predicted:  -1.628777835139772
Movie Vector:  [-2.1612071990966797, 0.35683631896972656]
User Vector:  [1.0791301727294922, 0.7188320159912109]
Predicted:  -2.0757185275215306
Movie Vector:  [2.537527084350586, 1.5622615814208984]
User Vector:  [-0.37178993225097656, 0.6387042999267578]
Predicted:  0.05439616688818205
Movie Vector:  [-0.1401403874029597, -1.056453256492197]
User Vector:  [0.014162063598632812, 0.4184436798095703]
Predicted:  -0.44405086527253645
Movie Vector:  [0.3144359588623047, -0.6354808807373047]
User Vector:  [-1.6606426239013672, 0.5599880218505859]
Predicted:  -0.8780274371019914
Movie Vector:  [-0.5000400543212891, -0.10891914367675781]
User Vector:  [-0.9017276763916016, 1.1233806610107422]
Predicted:  0.328542296665546
Movie Vector:  [0.4578685760498047, -0.2969837188720703]
User Vector:  [0.29633522033691406, 0.0060939788818359375]
Predicted:  0.13387277285801247
Movie Vector:  [0.12663841247558594, -0.9659290313720703]
User Vector:  [-0.5227184295654297, -0.45174598693847656]
Predicted:  0.3701583314978052
Movie Vector:  [1.4332103729248047, 2.1389293670654297]
User Vector:  [0.08278846740722656, -0.9622859954833984]
Predicted:  -1.9396084850086481
Movie Vector:  [1.7154216766357422, -0.29091835021972656]
User Vector:  [1.4107036590576172, 0.29120445251464844]
Predicted:  2.335234917154594
Movie Vector:  [0.5164127856819497, 0.5567643504370958]
User Vector:  [0.5943351260845148, 0.9084954008714803]
Predicted:  0.8127401098312357
Movie Vector:  [0.26381492614746094, -0.5900669097900391]
User Vector:  [1.1664485931396484, 0.6800556182861328]
Predicted:  -0.0935517677135067
Movie Vector:  [0.25183677673339844, -1.1213207244873047]
User Vector:  [0.26558876037597656, 0.5520534515380859]
Predicted:  -0.5521439588846988
Movie Vector:  [-2.1588914993727863, 0.2832308671741608]
User Vector:  [-0.6160259246826172, 1.2357044219970703]
Predicted:  1.6799227672037378
Movie Vector:  [0.54307385408339, 0.28487970295758863]
User Vector:  [-0.7448101043701172, -0.25053977966308594]
Predicted:  -0.4758605919500111
Movie Vector:  [-0.7379278804118248, -0.7894413358057148]
User Vector:  [-0.46545982360839844, 1.4704418182373047]
Predicted:  -0.8173517721616346
Movie Vector:  [-1.3699054718017578, 1.4191532135009766]
User Vector:  [-0.03354072570800781, -1.2595844268798828]
Predicted:  -1.7415956634067697
Movie Vector:  [0.8423900604248047, -1.474142074584961]
User Vector:  [-2.562723159790039, -0.6640529632568359]
Predicted:  -1.1799041045378544
Movie Vector:  [1.7561626434326172, -1.0105609893798828]
User Vector:  [0.05774497985839844, -0.8761119842529297]
Predicted:  0.9867741700873012
Movie Vector:  [1.0011959075927734, 0.5791568756103516]
User Vector:  [0.2937602996826172, 0.13457298278808594]
Predicted:  0.3720504781085765
Movie Vector:  [0.04498481750488281, -1.020975112915039]
User Vector:  [-0.5678272247314453, 1.0300159454345703]
Predicted:  -1.0771642502731993
Movie Vector:  [0.9980869293212891, 1.9187450408935547]
User Vector:  [0.7007694244384766, 1.3537311553955078]
Predicted:  3.296893744118279
Movie Vector:  [-0.8386135101318359, 1.9914913177490234]
User Vector:  [-1.8471622467041016, -0.3126811981201172]
Predicted:  0.9263533242119593
Movie Vector:  [-1.1106204986572266, -0.07409095764160156]
User Vector:  [1.3303661346435547, 0.4084491729736328]
Predicted:  -1.5077942902280483
Movie Vector:  [-1.0361003875732422, 1.272573471069336]
User Vector:  [1.2949848175048828, 0.3625202178955078]
Predicted:  -0.880400659298175
Movie Vector:  [0.1307201385498047, 0.9375476837158203]
User Vector:  [1.1534595489501953, 0.4476642608642578]
Predicted:  0.5704869829060044
Movie Vector:  [0.03926277160644531, -0.023813247680664062]
User Vector:  [-1.152944564819336, -0.5203723907470703]
Predicted:  -0.032876042496354785
Movie Vector:  [0.7376384735107422, -0.1513385772705078]
User Vector:  [-0.939338487426301, 1.1151882426324822]
Predicted:  -0.8616632100038238
Movie Vector:  [-0.8984851837158203, -1.6337299346923828]
User Vector:  [1.352529525756836, -0.2453136444091797]
Predicted:  -0.8144514951709425
Movie Vector:  [-0.7009220123291016, 0.1359844207763672]
User Vector:  [0.4456327937131014, -0.6077070619183554]
Predicted:  -0.3949925273459019
Movie Vector:  [2.893827500150982, -0.015051092542364052]
User Vector:  [0.6150913238525391, -0.03458976745605469]
Predicted:  1.7804888018597511
Movie Vector:  [0.2576732635498047, -1.1525249481201172]
User Vector:  [-0.6061077117919922, -1.3199329376220703]
Predicted:  1.3650778882947634
Movie Vector:  [-1.979990005493164, -0.3677654266357422]
User Vector:  [1.1996425657926733, -0.35223030400564065]
Predicted:  -2.245742162406997
Movie Vector:  [-1.2380504608154297, -0.29738426208496094]
User Vector:  [1.398477554321289, 0.7801532745361328]
Predicted:  -1.9633910864286008
Movie Vector:  [0.37367820739746094, 1.2496662139892578]
User Vector:  [-0.5572032928466797, 2.333860397338867]
Predicted:  2.7083317590950173
Movie Vector:  [2.9311275482177734, -1.792154312133789]
User Vector:  [-1.2883341200070024, -0.8237279490369931]
Predicted:  -2.3000240345696588
Movie Vector:  [1.411275863647461, -0.2991008758544922]
User Vector:  [1.2587451934814453, 0.14817237854003906]
Predicted:  1.732118221843848
Movie Vector:  [2.762784957885742, -0.9796428680419922]
User Vector:  [-1.6057700164957902, 0.44908946874420064]
Predicted:  -4.876344542566533
Movie Vector:  [-0.8099726902900238, 1.335876037233215]
User Vector:  [-0.2772998809814453, -1.7997074127197266]
Predicted:  -2.179580676067626
Movie Vector:  [0.09484291076660156, 0.04734992980957031]
User Vector:  [2.122220993041992, -0.9848690032958984]
Predicted:  0.15464413809240796
Movie Vector:  [-2.735261917114258, -2.9126644134521484]
User Vector:  [0.9524822235107422, 1.8947696685791016]
Predicted:  -8.124116538056114
Movie Vector:  [2.761087417602539, -0.34150123596191406]
User Vector:  [-2.2095775604248047, -1.5625286102294922]
Predicted:  -5.567231348686619
Movie Vector:

avg loss: 19.052752041695186:   0%|                                                | 91/70000 [00:00<01:17, 903.98it/s]

 [-1.3519763946533203, -1.329488754272461]
User Vector:  [0.5451107025146484, -0.1337146759033203]
Predicted:  -0.5592046443780418
Movie Vector:  [-0.31249046325683594, 0.20211219787597656]
User Vector:  [0.07742881774902344, 1.0719966888427734]
Predicted:  0.19246783976996085
Movie Vector:  [1.2162494659423828, 0.32904624938964844]
User Vector:  [0.12581825256347656, -0.21399497985839844]
Predicted:  0.08261213697551284
Movie Vector:  [0.4069232940673828, 0.9118747711181641]
User Vector:  [-1.6436100006103516, -1.272134780883789]
Predicted:  -1.8288508077603183
Movie Vector:  [-0.34783363342285156, -1.6001415252685547]
User Vector:  [0.5589008331298828, 0.6974887847900391]
Predicted:  -1.3104852754622698
Movie Vector:  [-0.8929157257080078, -0.3036975860595703]
User Vector:  [-0.1764965057373047, 0.7601642608642578]
Predicted:  -0.07326354552787961
Movie Vector:  [-1.6591548919677734, -0.8780765533447266]
User Vector:  [0.6356716156005859, -0.04548072814941406]
Predicted:  -1.0147421096917242
Movie Vector:  [1.8269824981689453, -0.2075672149658203]
User Vector:  [-1.363210678100586, 0.4659557342529297]
Predicted:  -2.587279184263025
Movie Vector:  [-0.9519481658935547, -0.7282733917236328]
User Vector:  [0.0055599212646484375, -1.512899398803711]
Predicted:  1.096511619653029
Movie Vector:  [-2.420206069946289, 0.026121139526367188]
User Vector:  [-0.5799388885498047, 0.1877117156982422]
Predicted:  1.4084748621826293
Movie Vector:  [0.32631874084472656, 1.4493656158447266]
User Vector:  [1.079252425812435, -0.7183150217714657]
Predicted:  -0.6889208012555881
Movie Vector:  [1.116323471069336, -0.3444957733154297]
User Vector:  [0.3759932379112637, -0.045573978987877746]
Predicted:  0.4354301195781906
Movie Vector:  [0.3503894805908203, 0.48941612243652344]
User Vector:  [1.3392650862976043, 0.13110727377534853]
Predicted:  0.5334304115155925
Movie Vector:  [0.3695964813232422, -0.8933353424072266]
User Vector:  [0.38695335388183594, 0.4648113250732422]
Predicted:  -0.2722157862081076
Movie Vector:  [0.5588054656982422, 1.1341381072998047]
User Vector:  [1.1372089385986328, 0.3724384307861328]
Predicted:  1.0578751875073067
Movie Vector:  [-1.1382389068603516, 0.2740192413330078]
User Vector:  [0.6728595584153143, 0.6689159837917115]
Predicted:  -0.5825790778470589
Movie Vector:  [-0.5585193634033203, -1.104726791381836]
User Vector:  [-1.7286551396950711, -0.33177751561627233]
Predicted:  1.3320108784457703
Movie Vector:  [0.9513391862514169, 2.2043655394355968]
User Vector:  [-1.2328348329709804, -0.3793028156521438]
Predicted:  -2.008966142615493
Movie Vector:  [-0.8730030059814453, 0.9427356719970703]
User Vector:  [0.7962322235107422, -0.3642749786376953]
Predicted:  -1.038528141361894
Movie Vector:  [0.45378684997558594, 0.43129920959472656]
User Vector:  [-1.8726444244384766, -0.03771781921386719]
Predicted:  -0.8660490801048581
Movie Vector:  [0.5508708953857422, 0.07256507873535156]
User Vector:  [-0.5892570295795477, -1.2511586907954961]
Predicted:  -0.41539497640482276
Movie Vector:  [0.43303489685058594, 2.0335865020751953]
User Vector:  [-0.9869861602783203, 0.9469509124755859]
Predicted:  1.498307143629063
Movie Vector:  [-2.093381881713867, 2.2333621978759766]
User Vector:  [-0.4087543487548828, -0.12246131896972656]
Predicted:  0.5821784672662034
Movie Vector:  [1.7613940592575594, -1.0899324968266157]
User Vector:  [-1.9134807586669922, 0.5838298797607422]
Predicted:  -4.006728799389297
Movie Vector:  [0.5760860443115234, 0.9952068328857422]
User Vector:  [-0.5276966094970703, -1.0576343536376953]
Predicted:  -1.3565635877966997
Movie Vector:  [-0.2331256866455078, -0.6857585906982422]
User Vector:  [-0.38926124572753906, -0.2199077606201172]
Predicted:  0.24155043120117625
Movie Vector:  [0.9229183197021484, 0.08770942687988281]
User Vector:  [-0.9755894097562141, 0.21676528950661395]
Predicted:  -0.881376979461339
Movie Vector:  [-0.1387500762939453, 0.43845176696777344]
User Vector:  [0.3042125701904297, -0.4997730255126953]
Predicted:  -0.2613358834423707
Movie Vector:  [-0.07292747497558594, 0.36744117736816406]
User Vector:  [1.088636895046933, 0.6362256655330238]
Predicted:  0.15438396769426327
Movie Vector:  [1.9646358489990234, -0.2319812774658203]
User Vector:  [0.9506724035821195, -1.3291285219324296]
Predicted:  2.176058017165642
Movie Vector:  [0.32965660095214844, 1.3507938385009766]
User Vector:  [0.6490802764892578, -1.1359310150146484]
Predicted:  -1.320435018351418
Movie Vector:  [-0.5367374420166016, -0.3551006317138672]
User Vector:  [-2.1144962310791016, -0.018415451049804688]
Predicted:  1.1414686365242233
Movie Vector:  [0.3553295135498047, -0.3826618194580078]
User Vector:  [-0.2818775177001953, 0.44135093688964844]
Predicted:  -0.2690475537747261
Movie Vector:  [0.41726112365722656, -0.43244361877441406]
User Vector:  [-0.33560752868652344, -1.6686725616455078]
Predicted:  0.5815708265799913
Movie Vector:  [-1.3310718536376953, -0.7506656646728516]
User Vector:  [0.8941173553466797, -0.018720626831054688]
Predicted:  -1.1760815137677127
Movie Vector:  [0.37604331970214844, 0.6084346771240234]
User Vector:  [-0.8030796051025391, 0.7487010955810547]
Predicted:  0.1535429886644124
Movie Vector:  [-0.36942481994628906, 0.29639244079589844]
User Vector:  [-0.15160560607910156, -0.2697277069091797]
Predicted:  -0.023938379672472365
Movie Vector:  [0.9953975677490234, -0.3061199188232422]
User Vector:  [-2.344198226928711, 0.6628704071044922]
Predicted:  -2.536327048619569
Movie Vector:  [1.7122173309326172, -0.10804176330566406]
User Vector:  [-0.6198596954345703, -0.6979274749755859]
Predicted:  -0.9859291982138529
Movie Vector:  [-1.5648174285888672, 1.2511348724365234]
User Vector:  [-0.3577756395964199, -1.0090812809465899]
Predicted:  -0.7026432233501883
Movie Vector:  [-1.3384532928466797, -0.8441257476806641]
User Vector:  [-0.5994510650634766, -0.5300617218017578]
Predicted:  1.2497759991674684
Movie Vector:  [-0.09259223937988281, 1.9624042510986328]
User Vector:  [-0.6277751922607422, 0.7869434356689453]
Predicted:  1.6024282544094604
Movie Vector:  [-0.6298732757568359, -0.37688255310058594]
User Vector:  [-0.6488323211669922, -0.5268001556396484]
Predicted:  0.6072239271816215
Movie Vector:  [-0.8873271942138672, 1.5176677703857422]
User Vector:  [1.2111923327680627, 0.5225933447687443]
Predicted:  -0.28160081791482594
Movie Vector:  [-0.6866931915283203, -0.9817028045654297]
User Vector:  [1.3069820404052734, 0.37467002868652344]
Predicted:  -1.2653102865442634
Movie Vector:  [-1.8062114715576172, -0.1669788360595703]
User Vector:  [1.4155864715576172, 0.5348873138427734]
Predicted:  -2.646163384997635
Movie Vector:  [-0.15786170959472656, 1.0392284393310547]
User Vector:  [1.9859790802001953, -1.8024158477783203]
Predicted:  -2.186631861331989

avg loss: 17.963442135285035:   0%|                                               | 182/70000 [00:00<01:47, 648.74it/s]

Movie Vector:  [-0.8305263519287109, -1.8671512603759766]
User Vector:  [-0.016698837280273438, 2.4236583709716797]
Predicted:  -4.511467957672721
Movie Vector:  [-0.4640483856201172, -0.19867897033691406]
User Vector:  [1.140909194946289, -0.3653430938720703]
Predicted:  -0.45685108034376753
Movie Vector:  [-0.7875728607177734, 0.08931159973144531]
User Vector:  [1.0532283782958984, -0.4448986053466797]
Predicted:  -0.8692286930454429
Movie Vector:  [0.01773375200126341, -1.0600470890978586]
User Vector:  [0.9566690431254079, 0.4924617732824653]
Predicted:  -0.505067337701975
Movie Vector:  [0.30800819396972656, 1.2107372283935547]
User Vector:  [-0.4745960235595703, -0.3011798858642578]
Predicted:  -0.5108291643409757
Movie Vector:  [1.0503864288330078, -0.6696796417236328]
User Vector:  [0.7772625886343155, 1.5007833561119608]
Predicted:  -0.1886179854847514
Movie Vector:  [-0.8627653746249776, -0.08802810333120223]
User Vector:  [-0.5558109283447266, 0.0022792816162109375]
Predicted:  0.47933378297636187
Movie Vector:  [-0.20972251892089844, -0.14649391174316406]
User Vector:  [0.37552833557128906, -1.4305782318115234]
Predicted:  0.13081425277050585
Movie Vector:  [0.11452674865722656, 1.5001773834228516]
User Vector:  [0.9789180755615234, -0.0053882598876953125]
Predicted:  0.10402895877632545
Movie Vector:  [0.1392841339111328, 1.4255237579345703]
User Vector:  [0.8460542667884913, -1.1918719873560768]
Predicted:  -1.5811998986013258
Movie Vector:  [0.011682510375976562, -0.8014583587646484]
User Vector:  [-2.210569381713867, -0.22841453552246094]
Predicted:  0.15723973901913268
Movie Vector:  [0.35584449768066406, 0.9989833831787109]
User Vector:  [0.4893571682163912, 0.7130922858334335]
Predicted:  0.8865023999309178
Movie Vector:  [0.9108351789106623, -1.6334340694922105]
User Vector:  [-0.33263206481933594, -0.9282398223876953]
Predicted:  1.213245564276317
Movie Vector:  [-0.9185123443603516, 1.0200214385986328]
User Vector:  [0.23962974548339844, 0.8624553680419922]
Predicted:  0.6596200859348755
Movie Vector:  [-2.200682959860915, -0.22860360322494933]
User Vector:  [-0.8345890045166016, -0.6728076934814453]
Predicted:  1.9904720637342947
Movie Vector:  [0.4747486114501953, 0.04490852355957031]
User Vector:  [0.6097316741943359, -0.1324748992919922]
Predicted:  0.28352001354505774
Movie Vector:  [-0.5678043309869452, -0.79612614607079]
User Vector:  [-0.8730792999267578, 1.084146499633789]
Predicted:  -0.36737916673612253
Movie Vector:  [0.8691218042161978, -1.7498390094026528]
User Vector:  [0.9569103432061253, 0.2961768942197438]
Predicted:  0.3134097607710179
Movie Vector:  [-0.925810996980877, -0.08776956446359425]
User Vector:  [-0.17373085021972656, -0.7638072967529297]
Predicted:  0.22788096541838038
Movie Vector:  [0.029535293579101562, 1.431741714477539]
User Vector:  [0.3390128434226077, -1.456084778803288]
Predicted:  -2.074724473770895
Movie Vector:  [-1.1589336395263672, 0.06512641906738281]
User Vector:  [-0.9308147430419922, 0.36337852478027344]
Predicted:  1.1024180599633837
Movie Vector:  [-0.09815524254660934, 0.5209499329473424]
User Vector:  [-0.1688098907470703, 0.5051898956298828]
Predicted:  0.27974821802460764
Movie Vector:  [-2.126321792602539, 0.6577587127685547]
User Vector:  [0.09419441223144531, 1.5418148040771484]
Predicted:  0.8138544893881772
Movie Vector:  [0.6026089117201727, 1.2654759387302743]
User Vector:  [1.113729476928711, 0.05934715270996094]
Predicted:  0.7462457018292945
Movie Vector:  [0.6880092620849609, -0.18921852111816406]
User Vector:  [-1.752614974975586, 0.43839454650878906]
Predicted:  -1.2887677034086664
Movie Vector:  [-0.5764865875244141, 0.09339332580566406]
User Vector:  [0.40205955505371094, 1.0760784149169922]
Predicted:  -0.1312833988777129
Movie Vector:  [-0.31380653381347656, -0.24245262145996094]
User Vector:  [0.6433010101318359, -1.4296627044677734]
Predicted:  0.14475341031356947
Movie Vector:  [0.7244586944580078, 0.8246898651123047]
User Vector:  [0.8733272552490234, -0.22568702697753906]
Predicted:  0.4465677193365991
Movie Vector:  [-0.016412734985351562, 1.3075733184814453]
User Vector:  [0.6416988372802734, -0.20424842834472656]
Predicted:  -0.27760182820202317
Movie Vector:  [1.2256145477294922, 2.5365352630615234]
User Vector:  [-0.20476341247558594, -0.6405162811279297]
Predicted:  -1.8756531508188345
Movie Vector:  [0.9492969512939453, -0.1658153533935547]
User Vector:  [-1.2547016143798828, -1.1652469635009766]
Predicted:  -0.9978685802707332
Movie Vector:  [-0.9252669809309845, -0.16436186430195157]
User Vector:  [-0.49338340759277344, 2.7391529083251953]
Predicted:  0.006299097364365125
Movie Vector:  [-0.35140029202279566, 1.3704521151747586]
User Vector:  [-1.0583972930908203, -0.6496524810791016]
Predicted:  -0.518396498955134
Movie Vector:  [-1.1709947557090403, 0.6222150073821546]
User Vector:  [0.3216266632080078, 0.3593921661376953]
Predicted:  -0.15300393660632028
Movie Vector:  [-0.133970400896097, -1.1901293864054439]
User Vector:  [-0.04347801208496094, 1.1249065399169922]
Predicted:  -1.3329595634056932
Movie Vector:  [0.8010768890380859, 0.4410839080810547]
User Vector:  [0.5241809832530064, -0.2273483818883315]
Predicted:  0.3196295585780341
Movie Vector:  [-0.9199047088623047, -1.619253158569336]
User Vector:  [-0.7011699676513672, -0.33308982849121094]
Predicted:  1.1843663118270342
Movie Vector:  [1.193554604474877, -0.3538569258472866]
User Vector:  [-1.765604019165039, -0.6080150604248047]
Predicted:  -1.8921944666030077
Movie Vector:  [1.4238262176513672, 1.1477947235107422]
User Vector:  [-0.8178043365478516, -1.1625003814697266]
Predicted:  -2.4987230592159904
Movie Vector:  [-0.8084392547607422, 0.06594657897949219]
User Vector:  [1.8899059295654297, 2.1720409393310547]
Predicted:  -1.384635471913498
Movie Vector:  [1.2416744232177734, 0.40762901306152344]
User Vector:  [-1.0777650488388273, 0.19660264865549185]
Predicted:  -1.2580923517445068
Movie Vector:  [0.3162165783499623, 1.4903457327971892]
User Vector:  [-1.0584163665771484, 0.11530876159667969]
Predicted:  -0.16283888110888528
Movie Vector:  [-0.9881305694580078, 0.5987071990966797]
User Vector:  [0.45546531677246094, -0.44074058532714844]
Predicted:  -0.713933764200192
Movie Vector:  [0.06928443908691406, -2.1286869049072266]
User Vector:  [1.289682388305664, 0.5614185333251953]
Predicted:  -1.105729359187535
Movie Vector:  [-0.08891105651855469, 1.4767169952392578]
User Vector:  [0.9761333465576172, 0.19148826599121094]
Predicted:  0.19598492963268654
Movie Vector:  [1.1056804656982422, 1.124429702758789]
User Vector:  [1.6048526763916016, 0.5775165557861328]
Predicted:  2.4238310237706173
Movie Vector:  [1.2917271911334853, 1.1913798133011677]
User Vector:  [2.3868465423583984, -0.10863304138183594]
Predicted:  2.953731367267456
Movie Vector:  [0.4308605194091797, 1.831197738647461]
User Vector:  [-1.2241268157958984, 1.3586139678955078]
Predicted:  1.960462910028582
Movie Vector:  [-0.3054523468017578, -0.21506309509277344]
User Vector:  [-0.34966468811035156, 0.7349872589111328]
Predicted:  -0.05126273517817026
Movie Vector:  [1.459063752714407, 1.8384244043986584]
User Vector:  [0.5777454376220703, -0.5473423004150391]
Predicted:  -0.16328001631222444
Movie Vector:  [0.9401607513427734, 0.0004100799560546875]
User Vector:  [-0.7798480987548828, -1.455373764038086]
Predicted:  -0.7337793940678239
Movie Vector:  [0.12970780859567388, -1.658812338081726]
User Vector:  [-0.6169986724853516, 1.8447399139404297]
Predicted:  -3.140106875510721
Movie Vector:  [1.4041049112121928, 1.186265142835741]
User Vector:  [0.1627063751220703, 0.6881427764892578]
Predicted:  1.044776609437845
Movie Vector:  [0.4286318034055066, -0.12433851895227732]
User Vector:  [1.200333198055759, -1.358608097022457]
Predicted:  0.6834283019904833
Movie Vector:  [0.7254069040377447, -0.5150713597063714]
User Vector:  [-0.001250896980499636, 0.3022525325053319]
Predicted:  -0.1565890321981099
Movie Vector:  [0.6179763615672327, 2.1018007394682363]
User Vector:  [1.1423015594482422, 1.9513225555419922]
Predicted:  4.8072065516996085
Movie Vector:  [-0.4764842987060547, -1.0126399993896484]
User Vector:  [-0.730720603974923, 0.2210341844935121]
Predicted:  0.12434883808445438
Movie Vector:  [-2.2787952423095703, -1.6744709014892578]
User Vector:  [0.38880348205566406, -0.8967494964599609]
Predicted:  0.6155774126455071
Movie Vector:  [0.12211011232123459, 1.5181130584421705]
User Vector:  [-0.7923797221993091, 0.08999421190539705]
Predicted:  0.039863811398968815
Movie Vector:  [-0.46280860900878906, -1.365671157836914]
User Vector:  [0.14969825744628906, -1.8152713775634766]
Predicted:  2.4097821216855664
Movie Vector:  [-1.376810073852539, -0.3323841094970703]
User Vector:  [-0.7358455657958984, -1.2919330596923828]
Predicted:  1.4425376073631924
Movie Vector:  [-1.5942859649658203, 1.8218708038330078]
User Vector:  [0.1363086700439453, -0.6122303009033203]
Predicted:  -1.3327195099918754
Movie Vector:  [-0.42525291442871094, -0.7459926605224609]
User Vector:  [1.7439746856689453, -0.024366378784179688]
Predicted:  -0.7234531780341058
Movie Vector:  [0.88788999789048, 0.4034312261737429]
User Vector:  [-0.2631092071533203, 0.6652736663818359]
Predicted:  0.034780137585198184
Movie Vector:  [1.1200237274169922, -0.012292861938476562]
User Vector:  [1.0408687591552734, 0.3679180145263672]
Predicted:  1.1612749420237378
Movie Vector:  [-2.482481002807617, 1.9939517974853516]
User Vector:  [1.5045833587646484, -1.2421894073486328]
Predicted:  -6.211965406873787
Movie Vector:  [0.9626865386962891, 0.7321834564208984]
User Vector:  [1.3585567474365234, 0.7934284210205078]
Predicted:  1.8887994565375266
Movie Vector:  [0.021448135375976562, 0.028924942016601562]
User Vector:  [-1.083919213908264, -1.1950778231166126]
Predicted:  -0.057815602775500984
Movie Vector:  [0.9270191192626953, 1.5722942352294922]
User Vector:  [0.07670402526855469, -0.5783176422119141]
Predicted:  -0.8381793970329454
Movie Vector:  [-0.9795475006103516, -0.19257545471191406]
User Vector:  [-1.6741085052490234, -0.3934955596923828]
Predicted:  1.7156463884020923
Movie Vector:  [0.36563484814756336, -0.6891343722270666]
User Vector:  [0.5552266151407151, 0.8980114945480869]
Predicted:  -0.41584038843362475
Movie Vector:  [1.422889278606177, -0.06944509205936603]
User Vector:  [0.09284019470214844, -0.33865928649902344]
Predicted:  0.1556195429930809
Movie Vector:  [0.5767211118414866, 0.022753209522885776]

avg loss: 17.8745947428003:   0%|▏                                                | 182/70000 [00:00<01:47, 648.74it/s]

User Vector:  [0.7878971099853516, 1.197347640991211]
Predicted:  0.481640399034652
Movie Vector:  [-0.57104268862958, -0.9840372249638664]
User Vector:  [0.7972431182861328, 1.3014507293701172]
Predicted:  -1.7359358179141133
Movie Vector:  [-0.8196735382080078, 0.04370689392089844]
User Vector:  [0.6138522209580957, 0.880295620937284]
Predicted:  -0.46468343456622874
Movie Vector:  [0.20560264587402344, -1.0251522064208984]
User Vector:  [-0.6062602996826172, 0.10487556457519531]
Predicted:  -0.23216213812702335
Movie Vector:  [-0.8746060600153545, 0.9163981990457708]
User Vector:  [0.03750801086425781, -1.4952945709228516]
Predicted:  -1.4030899854376213
Movie Vector:  [-0.11765480041503906, -0.40627479553222656]
User Vector:  [-0.5186677012371816, 2.462732314183769]
Predicted:  -0.9395223225248301
Movie Vector:  [0.4776287078857422, 0.28817176818847656]
User Vector:  [1.7139600520141065, -0.5357648387788668]
Predicted:  0.664244224087157
Movie Vector:  [0.3782176971435547, -0.2006244659423828]
User Vector:  [0.24105743077838215, 1.3097502321165322]
Predicted:  -0.17159575448794964
Movie Vector:  [-0.7603168487548828, -0.9217739105224609]
User Vector:  [0.40093421936035156, 0.5772686004638672]
Predicted:  -0.8369481774934684
Movie Vector:  [1.476449966430664, -0.7876300811767578]
User Vector:  [2.1085262298583984, -1.164541244506836]
Predicted:  4.030361196237209
Movie Vector:  [0.4756450653076172, 1.2040233612060547]
User Vector:  [-0.5045921535858836, -1.2400059625536148]
Predicted:  -1.7330029147954213
Movie Vector:  [2.12138340137147, -0.8002605895664662]
User Vector:  [2.856416702270508, -0.2021312713623047]
Predicted:  6.221312669987105
Movie Vector:  [0.2110144721203324, -0.569853544163099]
User Vector:  [-0.6843042224471607, -0.2188002703131256]
Predicted:  -0.0197139847676234
Movie Vector:  [-0.7660608532464569, -1.1445598374916586]
User Vector:  [1.291971206665039, -0.6430912017822266]
Predicted:  -0.25367220354349374
Movie Vector:  [-2.1012401580810547, -0.08503913879394531]
User Vector:  [-0.8559220077421331, 0.22813786606381883]
Predicted:

avg loss: 16.667943528435092:   0%|▏                                              | 321/70000 [00:00<01:47, 650.17it/s]